import axios from 'axios';

/**
 * 图像服务类 - 处理植物图像生成
 */
export default {
  /**
   * 根据植物状态和用户输入生成植物图像
   * @param {Object} plantState - 植物状态
   * @param {string} userInput - 用户输入的文本
   * @returns {Promise<string>} - 返回生成的图像URL或base64字符串
   */
  async generatePlantImage(plantState, userInput) {
    try {
      // 检查localStorage中是否已有缓存的图像
      const cacheKey = this.generateCacheKey(plantState, userInput);
      const cachedImage = localStorage.getItem(cacheKey);
      
      if (cachedImage) {
        console.log('使用缓存的植物图像');
        return cachedImage;
      }
      
      // 根据植物状态和变异类型构建提示词
      const prompt = this.buildPrompt(plantState, userInput);
      
      const response = await axios.post('https://api.siliconflow.cn/v1/images/generations', {
        model: 'Kwai-Kolors/Kolors',
        prompt: prompt,
        negative_prompt: 'blurry, low quality, distorted, deformed',
        image_size: '512x512',
        batch_size: 1,
        num_inference_steps: 20,
        guidance_scale: 7.5
      }, {
        headers: {
          Authorization: 'Bearer ' + process.env.VUE_APP_API_KEY,
          'Content-Type': 'application/json'
        }
      });
      
      // 获取图像URL
      const imageUrl = response.data.images[0].url;
      
      try {
        // 将图像转换为base64
        const base64Image = await this.convertImageToBase64(imageUrl);
        
        // 尝试存储到localStorage，但处理配额超出错误
        try {
          // 在存储前清理一些旧的图像缓存
          this.cleanupImageCache();
          localStorage.setItem(cacheKey, base64Image);
          return base64Image;
        } catch (storageError) {
          console.warn('localStorage存储失败，返回原始URL:', storageError);
          return imageUrl;
        }
      } catch (conversionError) {
        console.warn('图像转换失败，返回原始URL:', conversionError);
        return imageUrl;
      }
      
    } catch (error) {
      console.error('生成植物图像失败:', error);
      throw error;
    }
  },
  
  /**
   * 将图像URL转换为base64格式
   * @param {string} url - 图像URL
   * @returns {Promise<string>} - 返回base64格式的图像
   */
  async convertImageToBase64(url) {
    try {
      // 获取图像数据
      const response = await axios.get(url, { responseType: 'blob' });
      const blob = response.data;
      
      // 转换为base64
      return new Promise((resolve, reject) => {
        const reader = new FileReader();
        reader.onloadend = () => resolve(reader.result);
        reader.onerror = reject;
        reader.readAsDataURL(blob);
      });
    } catch (error) {
      console.error('转换图像为base64失败:', error);
      throw error;
    }
  },
  
  /**
   * 生成图像缓存的键
   * @param {Object} plantState - 植物状态
   * @param {string} userInput - 用户输入
   * @returns {string} - 缓存键
   */
  generateCacheKey(plantState, userInput) {
    // 创建一个唯一的缓存键，基于植物状态的关键属性
    const stateKey = `plant_${plantState.stage}_${plantState.variant}_${plantState.isDead ? 'dead' : 'alive'}_${plantState.growthValue}`;
    
    // 如果有用户输入，添加其哈希值（简化版）
    let inputKey = '';
    if (userInput && userInput.trim()) {
      inputKey = '_input_' + this.simpleHash(userInput.trim());
    }
    
    return `plant_image_${stateKey}${inputKey}`;
  },
  
  /**
   * 简单的字符串哈希函数
   * @param {string} str - 输入字符串
   * @returns {string} - 哈希值
   */
  simpleHash(str) {
    let hash = 0;
    for (let i = 0; i < str.length; i++) {
      const char = str.charCodeAt(i);
      hash = ((hash << 5) - hash) + char;
      hash = hash & hash; // 转换为32位整数
    }
    return Math.abs(hash).toString(16);
  },
  
  /**
   * 清理图像缓存，删除旧的图像数据
   */
  cleanupImageCache() {
    try {
      // 获取所有localStorage键
      const keys = [];
      for (let i = 0; i < localStorage.length; i++) {
        const key = localStorage.key(i);
        if (key && key.startsWith('plant_image_')) {
          keys.push(key);
        }
      }
      
      // 如果图像缓存超过10个，删除最旧的一半
      if (keys.length > 10) {
        // 按字母顺序排序（简单处理，实际上可以考虑添加时间戳）
        keys.sort();
        
        // 删除前一半的键
        const deleteCount = Math.floor(keys.length / 2);
        for (let i = 0; i < deleteCount; i++) {
          localStorage.removeItem(keys[i]);
        }
        console.log(`已清理 ${deleteCount} 个图像缓存`);
      }
    } catch (error) {
      console.error('清理图像缓存失败:', error);
    }
  },

  /**
   * 构建图像生成的提示词
   * @param {Object} plantState - 植物状态
   * @param {string} userInput - 用户输入的文本
   * @returns {string} - 返回构建的提示词
   */
  buildPrompt(plantState, userInput) {
    // 基础提示词
    let basePrompt = 'digital plant, cyber plant, futuristic plant';
    
    // 根据植物阶段添加描述
    const stageDescriptions = {
      seedling: 'small seedling, just sprouting, tiny plant',
      growing: 'growing plant, medium size, developing leaves',
      mature: 'mature plant, fully grown, lush foliage'
    };
    basePrompt += ', ' + stageDescriptions[plantState.stage];
    
    // 根据变异类型添加描述
    const variantDescriptions = {
      normal: 'healthy green plant, natural looking',
      dirty: 'plant with thorns, dark red color, spiky leaves, aggressive looking',
      happy: 'colorful plant, blooming flowers, vibrant colors, joyful appearance',
      code: 'plant with binary patterns, digital elements, glowing 0s and 1s, tech-inspired'
    };
    basePrompt += ', ' + variantDescriptions[plantState.variant];
    
    // 如果植物死亡，添加死亡描述
    if (plantState.isDead) {
      basePrompt += ', withered plant, dead leaves, gray color, dried out';
    }
    
    // 添加用户输入的关键词（提取名词和形容词）
    if (userInput && userInput.trim() !== '') {
      // 简单处理：取最后一句话中的关键词
      const lastSentence = userInput.split(/[.!?。！？]/).pop() || userInput;
      const keywords = lastSentence
        .replace(/[^\w\s\u4e00-\u9fa5]/g, '') // 保留中英文和空格
        .split(/\s+/)
        .filter(word => word.length > 1) // 过滤掉太短的词
        .slice(0, 3) // 最多取3个关键词
        .join(', ');
      
      if (keywords) {
        basePrompt += ', inspired by: ' + keywords;
      }
    }
    
    // 添加高质量修饰词
    basePrompt += ', high quality, detailed, 4k, realistic texture';
    
    return basePrompt;
  }
};